import re
import random
import time, datetime
import uuid
import socket
from hashlib import md5, sha1


class FunctionHelper:

    @staticmethod
    def __replace_func(matched):
        value = matched.group('value')
        func_str = re.search('\$(.*?)\$', value).group(1)

        # 解析函数名和参数
        if '(' in func_str and func_str.endswith(')'):
            func_name = func_str.split('(')[0]
            params_str = func_str[len(func_name) + 1:-1]

            # 处理参数
            if params_str.strip():
                # 分割参数
                params = [p.strip() for p in params_str.split(',')]
                # 转换参数类型
                args = []
                for p in params:
                    # 尝试转换为数字
                    if p.isdigit():
                        args.append(int(p))
                    elif p.replace('.', '', 1).isdigit() and p.count('.') == 1:
                        args.append(float(p))
                    # 处理字符串参数 (带引号)
                    elif (p.startswith('\'') and p.endswith('\'')) or (p.startswith('"') and p.endswith('"')):
                        args.append(p[1:-1])
                    # 其他情况保持原样
                    else:
                        args.append(p)

                return_value = getattr(Function, func_name)(*args)
            else:
                # 空参数列表
                return_value = getattr(Function, func_name)()
        else:
            # 无参数函数
            return_value = getattr(Function, func_str)()

        return str(return_value)

    @staticmethod
    def parse_function_str(function_str):
        # 支持带参数的函数调用，例如 $random_int(1,100)$
        return re.sub('(?P<value>\$([a-zA-Z0-9_]+(?:\([^)]*\))?)\$)', FunctionHelper.__replace_func, function_str)


class Function:

    @staticmethod
    def random_string(randomlength=16):
        """
        生成一个指定长度的随机字符串
        """
        random_str = ''
        base_str = 'ABCDEFGHIGKLMNOPQRSTUVWXYZabcdefghigklmnopqrstuvwxyz0123456789'
        length = len(base_str) - 1
        for i in range(randomlength):
            random_str += base_str[random.randint(0, length)]
        return random_str

    @staticmethod
    def md5(string):
        """
        将字符串使用MD5算法加密
        """
        return md5(str(string).encode('utf8')).hexdigest()

    @staticmethod
    def sha1(string):
        """
        将字符串使用SHA1算法加密
        """
        return sha1(str(string).encode('utf-8')).hexdigest()

    @staticmethod
    def times(fmt=None):

        """
          生成时间戳
        """
        if fmt is None:

            t = time.time()
            return int(round(t * 1000))
        else:

            return datetime.datetime.now().strftime(fmt)

    @staticmethod
    def uuid():
        """
            生成UUID
        """
        return uuid.uuid4()

    @staticmethod
    def machine_ip():

        """
            获取本机IP
        """
        name = socket.getfqdn(socket.gethostname())
        address = socket.gethostbyname(name)
        return address

    @staticmethod
    def random_int(min_val=0, max_val=100):
        """
        生成指定范围内的随机整数
        
        Args:
            min_val (int): 最小值，默认为0
            max_val (int): 最大值，默认为100
            
        Returns:
            int: 随机整数
        """
        return random.randint(min_val, max_val)

    @staticmethod
    def random_float(min_val=0.0, max_val=1.0, precision=2):
        """
        生成指定范围内的随机浮点数
        
        Args:
            min_val (float): 最小值，默认为0.0
            max_val (float): 最大值，默认为1.0
            precision (int): 小数位数，默认为2
            
        Returns:
            float: 随机浮点数
        """
        return round(random.uniform(min_val, max_val), precision)

    @staticmethod
    def random_choice(choices):
        """
        从给定列表中随机选择一个元素
        
        Args:
            choices (list): 选择列表
            
        Returns:
            Any: 随机选择的元素
        """
        return random.choice(choices)

    @staticmethod
    def random_email(domain="example.com"):
        """
        生成随机邮箱地址
        
        Args:
            domain (str): 邮箱域名，默认为example.com
            
        Returns:
            str: 随机邮箱地址
        """
        username = Function.random_string(8).lower()
        return f"{username}@{domain}"

    @staticmethod
    def random_phone(country_code="86"):
        """
        生成随机手机号码
        
        Args:
            country_code (str): 国家代码，默认为86（中国）
            
        Returns:
            str: 随机手机号码
        """
        if country_code == "86":
            # 中国手机号格式：1开头，第二位为3-9，后面9位数字
            second_digit = random.choice([3, 4, 5, 6, 7, 8, 9])
            remaining = ''.join([str(random.randint(0, 9)) for _ in range(9)])
            return f"1{second_digit}{remaining}"
        else:
            # 其他国家简单生成10位数字
            return ''.join([str(random.randint(0, 9)) for _ in range(10)])

    @staticmethod
    def format_time(timestamp=None, fmt="%Y-%m-%d %H:%M:%S"):
        """
        格式化时间戳
        
        Args:
            timestamp (float): 时间戳，默认为当前时间
            fmt (str): 时间格式，默认为'%Y-%m-%d %H:%M:%S'
            
        Returns:
            str: 格式化后的时间字符串
        """
        if timestamp is None:
            timestamp = time.time()
        return datetime.datetime.fromtimestamp(timestamp).strftime(fmt)

    @staticmethod
    def add_days(days=0, fmt="%Y-%m-%d"):
        """
        获取当前日期加上指定天数后的日期
        
        Args:
            days (int): 要添加的天数，可以为负数
            fmt (str): 日期格式，默认为'%Y-%m-%d'
            
        Returns:
            str: 格式化后的日期字符串
        """
        target_date = datetime.datetime.now() + datetime.timedelta(days=days)
        return target_date.strftime(fmt)

    @staticmethod
    def random_date(start_date="2020-01-01", end_date="2025-12-31", fmt="%Y-%m-%d"):
        """
        生成指定范围内的随机日期
        
        Args:
            start_date (str): 开始日期
            end_date (str): 结束日期
            fmt (str): 日期格式
            
        Returns:
            str: 随机日期字符串
        """
        start = datetime.datetime.strptime(start_date, fmt)
        end = datetime.datetime.strptime(end_date, fmt)

        time_between = end - start
        days_between = time_between.days
        random_days = random.randrange(days_between)

        random_date = start + datetime.timedelta(days=random_days)
        return random_date.strftime(fmt)

    @staticmethod
    def base64_encode(text):
        """
        Base64编码
        
        Args:
            text (str): 要编码的文本
            
        Returns:
            str: Base64编码后的字符串
        """
        import base64
        return base64.b64encode(text.encode('utf-8')).decode('utf-8')

    @staticmethod
    def base64_decode(encoded_text):
        """
        Base64解码
        
        Args:
            encoded_text (str): Base64编码的字符串
            
        Returns:
            str: 解码后的文本
        """
        import base64
        return base64.b64decode(encoded_text.encode('utf-8')).decode('utf-8')

    @staticmethod
    def url_encode(text):
        """
        URL编码
        
        Args:
            text (str): 要编码的文本
            
        Returns:
            str: URL编码后的字符串
        """
        import urllib.parse
        return urllib.parse.quote(text)

    @staticmethod
    def url_decode(encoded_text):
        """
        URL解码
        
        Args:
            encoded_text (str): URL编码的字符串
            
        Returns:
            str: 解码后的文本
        """
        import urllib.parse
        return urllib.parse.unquote(encoded_text)

    @staticmethod
    def random_boolean():
        """
        生成随机布尔值
        
        Returns:
            bool: 随机布尔值
        """
        return random.choice([True, False])

    @staticmethod
    def random_mac_address():
        """
        生成随机MAC地址
        
        Returns:
            str: 随机MAC地址
        """
        mac = [random.randint(0x00, 0xff) for _ in range(6)]
        return ":".join(["{:02x}".format(x) for x in mac])
